Multitask Learning As Question Answering

ABSTRACT

Approaches for multitask learning as question answering include an input layer for encoding a context and a question, a self-attention based transformer including an encoder and a decoder, a first bi-directional long-term short-term memory (biLSTM) for further encoding an output of the encoder, a long-term short-term memory (LSTM) for generating a context-adjusted hidden state from the output of the decoder and a hidden state, an attention network for generating first attention weights based on an output of the first biLSTM and an output of the LSTM, a vocabulary layer for generating a distribution over a vocabulary, a context layer for generating a distribution over the context, and a switch for generating a weighting between the distributions over the vocabulary and the context, generating a composite distribution based on the weighting, and selecting a word of an answer using the composite distribution.

RELATED APPLICATIONS

This application claims the benefit of U.S. Provisional Patent Application No. 62/628,850 filed Feb. 9, 2018 and entitled “Multitask Learning as Question Answering”, which is incorporated by reference in its entirety.

This application is related to contemporaneously filed U.S. Patent Application entitled “Multitask Learning as Question Answering” (Atty. Docket No. 70689.9US01 A3341US1), which is incorporated by reference in its entirety.

TECHNICAL FIELD

The present disclosure relates generally to natural language processing and more specifically to answering natural language questions about a natural language context.

BACKGROUND

Natural language processing and the ability of a system to answer natural language questions about the content of a natural language sample is a benchmark to test for context-specific reasoning about information provided in natural language form. This can be a complex task because there are many different types of natural language questions that can be asked and whose answering may require different types of reasoning and/or different types of analysis.

Accordingly, it would be advantageous to have unified systems and methods for simultaneously being able to answer different kinds of natural language questions.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a simplified diagram of natural language processing tasks according to some embodiments.

FIG. 2 is a simplified diagram of a computing device according to some embodiments.

FIG. 3 is a simplified diagram of a system for multitask question answering according to some embodiments.

FIG. 4 is a simplified diagram of an attention network according to some embodiments.

FIG. 5 is a simplified diagram of a layer for an attention-based transformer network according to some embodiments.

FIG. 6 is a simplified diagram of a word generator according to some embodiments.

FIG. 7 is a simplified diagram of a method of multitask learning according to some embodiments.

FIGS. 8 and 9A-9C are simplified diagrams of training performance according to some embodiments.

FIGS. 10A and 10B are simplified diagrams of training performance based on training order according to some embodiments.

In the figures, elements having the same designations have the same or similar functions.

DETAILED DESCRIPTION

Context specific reasoning, including context specific reasoning regarding the content of natural language information, is an important problem in machine intelligence and learning applications. Context specific reasoning may provide valuable information for use in the interpretation of natural language text and can include different tasks, such as answering questions about the content of natural language text, language translation, semantic context analysis, and/or the like. However, each of these different types of natural language processing tasks often involve different types of analysis and/or different types of expected responses.

Multitask learning in natural language processing has made progress when the task types are similar. However, when tackling different types of tasks, such as language translation, question answering and classification, parameter sharing is often limited to word vectors or subsets of parameters. The final architectures are typically highly optimized and engineered for each task type, limiting their ability to generalize across task types.

However, many of these task types can be handled by the same architecture and model when framed as a single type of task. For example, it is possible to treat many, if not all, natural language processing tasks as question answering tasks. For example, the task types of classification, language translation, and question answering may all be framed as question answering tasks. Examples of each of these three task types in question answering form are shown in FIG. 1.

FIG. 2 is a simplified diagram of a computing device 200 according to some embodiments. As shown in FIG. 2, computing device 200 includes a processor 210 coupled to memory 220. Operation of computing device 200 is controlled by processor 210. And although computing device 200 is shown with only one processor 210, it is understood that processor 210 may be representative of one or more central processing units, multi-core processors, microprocessors, microcontrollers, digital signal processors, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), graphics processing units (GPUs) and/or the like in computing device 200. Computing device 200 may be implemented as a stand-alone subsystem, as a board added to a computing device, and/or as a virtual machine.

Memory 220 may be used to store software executed by computing device 200 and/or one or more data structures used during operation of computing device 200. Memory 220 may include one or more types of machine readable media. Some common forms of machine readable media may include floppy disk, flexible disk, hard disk, magnetic tape, any other magnetic medium, CD-ROM, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, RAM, PROM, EPROM, FLASH-EPROM, any other memory chip or cartridge, and/or any other medium from which a processor or computer is adapted to read.

Processor 210 and/or memory 220 may be arranged in any suitable physical arrangement. In some embodiments, processor 210 and/or memory 220 may be implemented on a same board, in a same package (e.g., system-in-package), on a same chip (e.g., system-on-chip), and/or the like. In some embodiments, processor 210 and/or memory 220 may include distributed, virtualized, and/or containerized computing resources. Consistent with such embodiments, processor 210 and/or memory 220 may be located in one or more data centers and/or cloud computing facilities.

As shown, memory 220 includes a question answering module 230 that may be used to implement and/or emulate the question answering systems and models described further herein and/or to implement any of the methods described further herein. In some examples, question answering module 230 may be used to answer natural language questions about natural language contexts. In some examples, question answering module 230 may also handle the iterative training and/or evaluation of a question answering system or model used to answer natural language questions about natural language contexts. In some examples, memory 220 may include non-transitory, tangible, machine readable media that includes executable code that when run by one or more processors (e.g., processor 210) may cause the one or more processors to perform the counting methods described in further detail herein. In some examples, question answering module 230 may be implemented using hardware, software, and/or a combination of hardware and software. As shown, computing device 200 receives a natural language context 240 and a natural language question 250 about natural language context 240, which are provided to question answering module 230, question answering module 230 then generates a natural language answer 260 to natural language question 250 based on the content of natural language context 240.

FIG. 3 is a simplified diagram of a system 300 for multitask question answering according to some embodiments. System 300 receives a natural language context c and a natural language question q. Each of context c and question q are encoded into vectors for processing by system 300. In some examples, each of the words in context c and question q are encoded using a word encoding. In some examples, the encoding of each word is based on the GloVe encodings where each word is encoded as an element of

³⁰⁰. In some examples, the encoding of each word is based on the character n-gram encodings where each word is encoded as an element of

¹⁰⁰. In some example, the encoding of each word is based on a concatenation of GloVe and character engram encodings. In some examples, when there is no GloVe and/or character n-gram encoding for a word (e.g., the word is not in English), a random encoding is selected from a Normal distribution having a mean and standard deviation that is the same as the GloVe encodings (e.g., mean of zero and standard deviation of 0.4), with the same random encoding used consistently for each occurrence of the respective word.

The encodings for context c are then passed to a linear layer 310 and the encodings for question q are passed to a linear layer 315. Each of linear layer 310 and 315 implement a respective transfer function consistent with Equation 1, where W and b are the weights and bias of the respective linear layer 310 or 315, a is the output of the respective linear layer 310 or 315, x is the input to the respective linear layer 310 or 315, and f is a linear transfer function of the respective linear layer 310 or 315, such as a pure linear function, a saturating linear function, and/or the like. In some examples, linear layers 310 and 315 reduce the dimensionality of the encodings for context c and question q. In some examples, the dimensionality of the encodings is reduced to that each encoding is an element of

³⁰⁰.

a=f(Wx+b)   Equation 1

The encodings output by linear layers 310 and 315 are, respectively, further encoded by a one-layer bidirectional long short-term memory network (biLSTM) 320 to form c and by a biLSTM 325 to form {tilde over (q)}. In some examples, biLSTM 320 and/or 325 may further reduce the dimensionality of the encodings for context c and question q. Each of biLSTMs 320 and 325 generates an output at each time step i as h, as the concatenation of h_(i) ^(→) and h_(i) ^(←) according to Equation 2, where x is the input to the respective biLSTM and LSTM corresponds to a long-term short-term memory network. In some examples, biLSTMs 320 and/or 325 have a hidden size of 200 and further reduce the dimensionality of the encodings of {tilde over (c)} and {tilde over (q)} to elements of

^(200.)

h _(i) ⁴³=LSTM(x _(i) ,h _(i−1) ⁴³)

h _(i) ⁷⁷=LSTM(x _(i) ,h _(i+1) ^(←))   Equation 2

The outputs {tilde over (c)} and {tilde over (q)} are then passed to a coattention layer 330. Coattention layer 330 first prepends {tilde over (c)} with a context sentinel vector and prepends {tilde over (q)} with a question sentinel vector. The sentinel vectors allow the coattention mechanism of coattention layer 330 to refrain from aligning all of the tokens between the two sequences. Coattention layer 330 then stacks the vectors {tilde over (c)} and {tilde over (q)} along the time dimension to get Ĉ and {circumflex over (Q)}, respectively. Coattention layer 330 then generates an affinity matrix A according to Equation 3.

A=Ĉ^(T){circumflex over (Q)}  Equation 3

Coattention layer 330 then generates attention weights A_(c) and A_(q) over each sequence using Equation 4, where softmax(X) normalizes over the columns of X.

A _(c)=softmax(A)

A _(q)=softmax(A ^(T))   Equation 4

Coattention layer 330 then uses the attention weight A_(c) and A_(q) to generate weighted summations of the context and question as {tilde over (C)} and {tilde over (Q)}, respectively, using Equation 5.

{tilde over (C)}=ĈA_(c)

{tilde over (Q)}={circumflex over (Q)}A_(q)   Equation 5

Coattention layer 330 then generates a coattention summary S as the concatenation of {tilde over (C)}A_(q) and {tilde over (Q)}. The coattention summary S includes a sequence of vectors s and the first vector from s, which corresponds to the sentinel position, may be dropped. S is then passed to a biLSTM 340. biLSTM 340 generates an outputs to which positional encodings are added.

Outputs ŝ then passed to a multi-layer self-attention-based transformer that generates encodings {tilde over (s)}_(i) for each of the layers i of the multi-layer self-attention-based transformer. As shown in FIG. 3, the multi-layer self-attention-based transformer includes transformer layers 351 and 352. And although the multi-layer self-attention-based transformer is shown with two layers, in some embodiments the multi-layer self-attention-based transformer may include only a single layer or three or more layers. Each transformer layer 351 and 352 includes multi-head self-attention mechanisms that are followed by a position-wise fully connected feed-forward network along with a residual connection and layer normalization as is described in further detail below with respect to FIGS. 4 and 5.

FIG. 4 is a simplified diagram of an attention network 400 according to some embodiments. As shown in FIG. 4, attention network 400 receives a query q ∈

^(d) ^(q) , a key k ∈

^(d) ^(k) , and a value v ∈

^(d) ^(v) . Each of the q, k, and v are subject to respective weights W^(Q) 410, W^(K) 420, and W^(V) 430 according to Equations 6-8. The weights W^(Q) 410, W^(K) 420, and W^(V) 430 are altered during training using back propagation.

Q=qW^(Q) ∈

^(d) ^(q)   Equation 6

K=kW^(K) ∈

^(d) ^(k)   Equation 7

V=vW^(V) ∈

^(d) ^(v)   Equation 8

The resulting Q, K, and V vectors are passed through an attention transfer function 440, which generates a dot product of Q and K, which is then applied to V according to Equation 9.

$\begin{matrix} {{{Attention}\mspace{14mu} \left( {Q,K,V} \right)} = {{{{softmax}\left( \frac{QK^{T}}{\sqrt{d_{k}}} \right)}V} \in {\mathbb{R}}^{d_{v}}}} & {{Equation}\mspace{14mu} 9} \end{matrix}$

An addition and normalization module 450 is then used to combine the query q with the output from attention transfer function to provide a residual connection that improves the rate of learning by attention network 400. Addition and normalization module 450 implements Equation 10 where μ and σ are the mean and standard deviation, respectively, of the input vector and g_(i) is gain parameter for scaling the layer normalization. The output from addition and normalization module 450 is the output of attention network 400.

$\begin{matrix} {{{LayerNorm}\left( {{{Attention}\mspace{14mu} \left( {Q,K,V} \right)} + q} \right)}{{{LayerNorm}\left( a_{i} \right)} = {g_{i}\frac{a_{i} - \mu}{\sigma}}}} & {{Equation}\mspace{14mu} 10} \end{matrix}$

Attention network 400 is often used in two variant forms. The first variant form is a multi-head attention layer where multiple attention networks consistent with attention network 400 are implemented in parallel, which each of the “heads” in the multi-head attention network having its own weights W^(Q) 410, W^(K) 420, and W^(V) 430, which are initialized to different values and thus trained to learn different encodings. The outputs from each of the heads are then concatenated together to form the output of the multi-head attention layer. The second variant form is a self-attention layer that is a multi-head attention layer where the q, k, and v inputs are the same for each head of the attention network.

Self-attention based layers are further described in Vaswani, et al., “Attention is All You Need,” arXiv preprint arXiv: 1706.03762, submitted Jun. 12, 2017, which is hereby incorporated by reference in its entirety.

FIG. 5 is a simplified diagram of a layer 500 for an attention-based transformer network according to some embodiments. According to some embodiments, each transformer layer 351 and/or 352 of system 300 is consistent with layer 500. As shown in FIG. 5, layer 500 includes an encoding layer 510 and a decoding layer 520.

Encoding layer 510 receives layer input (e.g., from an input network for a first layer in an encoding stack or from layer output of a next lowest layer for all other layers of the encoding stack) and provides it to all three (q, k, and v) inputs of a multi-head attention layer 511, thus multi-head attention layer 511 is configured as a self-attention network. Each head of multi-head attention layer 511 is consistent with attention network 400. In some examples, multi-head attention layer 511 includes three heads, however, other numbers of heads such as two or more than three are possible. In some examples, each attention layer has a dimension of 200 and a hidden size of 128. The output of multi-head attention layer 511 is provided to a feed forward network 512 with both the input and output of feed forward network 512 being provided to an addition and normalization module 513, which generates the layer output for encoding layer 510. In some examples, feed forward network 512 is a two-layer perceptron network, which implements Equation 11 where γ is the input to feed forward network 512 and M_(i) and b_(i) are the weights and biases respectively of each of the layers in the perceptron network. In some examples, addition and normalization module 513 is substantially similar to addition and normalization module 450.

FF(γ)=max(0,γM ₁ +b ₁)M ₂ +b ₂   Equation 11

Decoding layer 530 receives layer input (e.g., from an input network for a first layer in a decoding stack or from layer output of a next lowest layer for all other layers of the decoding stack) and provides it to all three (q, k, and v) inputs of a multi-head attention layer 521, thus multi-head attention layer 521 is configured as a self-attention network. Each head of multi-head attention layer 521 is consistent with attention network 400. In some examples, multi-head attention layer 521 includes three heads, however, other numbers of heads such as two or more than three are possible. The output of multi-head attention layer 511 is provided as the q input to another multi-head attention layer 522 and the k and v inputs of multi-head attention layer 522 are provided with the encoding {tilde over (s)}_(i) output from the corresponding encoding layer. Each head of multi-head attention layer 521 is consistent with attention network 400. In some examples, multi-head attention layer 522 includes three heads, however, other numbers of heads such as two or more than three are possible. In some examples, each attention layer has a dimension of 200 and a hidden size of 128. The output of multi-head attention layer 522 is provided to a feed forward network 523 with both the input and output of feed forward network 523 being provided to an addition and normalization module 524, which generates the layer output for encoding layer 510. In some examples, feed forward network 523 and addition and normalization module 524 are substantially similar to feed forward network 512 and addition and normalization module 513, respectively.

Referring back to FIG. 3, the output of the encoding side of the multi-layer self-attention-based transformer (e.g., {tilde over (s)}_(i) in the examples of FIG. 3) is passed to a biLSTM 360, which generates the final encoded sequence h. The final encoded sequence h is then passed to a word generator 370 as is described in further detail below with respect to FIG. 6. In some examples, biLSTM 360 has a hidden size of 200.

The output of the decoding side of the multi-layer self-attention-based transformer is a sequence of vectors z. The sequence of vectors z is also passed to word generator 370 and as each of the words in the answer p are generated, they are passed back to the first layer of the decoding side of the multi-layer self-attention-based transformer

FIG. 6 is a simplified diagram of word generator 370 according to some embodiments. Word generator 370 treats z as a sequence of input vectors and h as its context for attention. Word generator operates iteratively to generate the answer p for system 300. Answer p is first initialized using a sentinel entry, which is removed after the complete answer p is generated. At each iteration t (as denoted by the subscripts in FIG. 6), a next word in answer p is generated as p_(t) as further described below.

At time-step t, a one-layer, unidirectional LSTM 610 produces a context-adjusted hidden state h_(t) ^(dec) based on a concatenation of the previous input z_(t−1) from the decoder side of the multi-layer self-attention-based transformer and a previous hidden-state {tilde over (h)}_(t−1) from the previous time step t as well as the previous context-adjusted hidden state h_(t−1) ^(dec) using Equation 12.

h _(t) ^(dec)=LSTM([z _(t−1) ;{tilde over (h)} _(t−1)],h _(t−1) ^(dec))   Equation 12

An attention layer 620 then generates a vector of attention weights α^(t) representing the relevance of each encoding time-step to the current decoder state based on the final encoded sequence h and the context-adjusted hidden state h_(t) ^(dec) using Equation 13, where H is the elements of h stacked over the time dimension and W₁ and b₁ are trainable weights and a bias for attention layer 620.

α^(t)=softmax(H(W ₁ h _(t) ^(dec) +b ₁))   Equation 13

A vocabulary layer including a tanh layer 630 and a softmax layer 640 then generates a distribution over each of the words in a vocabulary p_(vocab)(w_(t)) that are candidates as the next word p_(t) of the answer p. Tanh layer 630 generates the hidden state {tilde over (h)}_(t) for the current time step based on the attention weights α^(t), the final encoded sequence h, and the context-adjusted hidden state h_(t) ^(dec) using Equation 14, where H is the elements of h stacked over the time dimension and W₂ and b₂ are trainable weights and a bias for tanh layer 630.

{tilde over (h)} _(t)=[tanh(W ₂ H ^(T)α^(t) +b ₂ ;h _(t) ^(dec))]  Equation 14

Softmax layer 640 generates the distribution over each of the words in a vocabulary p_(vocab)(w_(t)) that are candidates as the next word p_(t) of the answer p based on the hidden state {tilde over (h)}_(t) using Equation 15, where W_(out) and b_(out) are trainable weights and a bias for softmax layer 640.

p _(vocab)(w _(t))=softmax(W _(out) {tilde over (h)} _(t) +b _(out))   Equation 15

A context layer 650 generates a distribution over each of the words in context c p_(copy)(w_(t)) that are candidates as the next word p_(t) of the answer p based on the attention weights α^(t) using Equation 16.

$\begin{matrix} {{p_{copy}\left( w_{t} \right)} = {\sum\limits_{{i:c_{i}} = w_{t}}\alpha_{i}^{t}}} & {{Equation}\mspace{14mu} 16} \end{matrix}$

A switch 660 decides how to weight the p_(vocab)(w_(t)) and p_(copy)(w_(t)) distributions relative to each other. Switch 660 first generates a weighting factor γ based on a concatenation of the hidden state {tilde over (h)}_(t), the context-adjusted hidden state h_(t) ^(dec), and the previous input z_(t−1) from the decoder side of the multi-layer self-attention-based transformer using Equation 17, where σ represents a sigmoid transfer function such as log-sigmoid, hyperbolic tangent sigmoid, and/or the like and W_(switch) are trainable weights for the weighting factor layer. In some examples, the weighting factor γ may further be determined using a trainable bias b_(switch).

γ=σ(W _(switch)[{tilde over (h)} _(t) ;h _(t) ^(dec) ;z _(t−1)])   Equation 17

Switch 660 then generates a final output distribution over the union of words in the vocabulary and words in the context using the weighting factor γ using Equation 18. The next word p_(t) in the answer p can then be determined based on the word in p(w_(t)) with the largest weighting.

p(w _(t))=γp _(vocab)(w _(t))+(1−γ)p _(copy)   Equation 18

As discussed above and further emphasized here, FIG. 3 is merely an example which should not unduly limit the scope of the claims. One of ordinary skill in the art would recognize many variations, alternatives, and modifications. According to some embodiments, one or more of the layers in system 300 are optional and may be omitted. In some examples, linear layers 310 and/or 315 are optional and may be omitted with the encodings used for context c and question q being passed directly to biLSTM 320 and 325, respectively. In some examples, biLSTMs 320 and/or 325 are optional and may be omitted with the output of linear layers 310 and 315 being passed directly to coattention layer 330. In some examples, linear layers 310 and 315 and biLSTMs 320 and 325 are optional and may be omitted with the encodings used for context c and question q being passed directly to coattention layer 330.

Because system 300 is used for multiple tasks (e.g., classification (such as sentiment analysis), language translation, and question answering) and shares its parameters for the various layers across all the task types, it may be susceptible to catastrophic forgetting if it is not trained carefully. To address this, in some embodiments, system 300 may be trained according to a joint strategy where system 300 is trained using an ordering where training samples are presented so as to train system 300 against a balanced mix of each of the task types concurrently. That is, the order in which training samples are presented to system 300 selects consecutive training samples or consecutive small groups (e.g., 2-10 or so) training samples from different task types. In some examples, the joint strategy includes selecting a training sample (context c, questions q, and ground truth answer) from a different one of the task types with each iteration of the training. The goal of the joint strategy is to train against each of the task types concurrently without overly focusing on one task type over another. In practice, however, while system 300 learns each of the task types, it does not learn any of the task types particularly well. The joint training strategy is described in more detail in Collobert, et al. “A Unified Architecture for Natural Language Processing: Deep Neural Networks with Multitask Learning,” International Conference on Machine Learning 2008, pp. 160-167 and Hashimoto, et al., “A Joint Many-task Model: Growing a Neural Network for Multiple NLP Tasks,” Conference on Empirical Methods in Natural Language Processing, 2017, pp. 1923-33, each of which is incorporated by reference in its entirety.

In some embodiments, system 300 may be trained according to a sequential training strategy where system 300 is trained using an ordering where training samples are presented to system 300 so as to train system 300 against each of the task types individually. That is, the order in which training samples are presented to system 300 for training is to present each of the samples for a first task type before presenting each of the training samples for a second task type, and so on before again presenting each of the samples for the first task type again, etc. In the sequential training strategy, when the training against one of the type types finishes and the training switches to a second of the task types some catastrophic forgetting of the first task type begins to occur. However, after multiple passes through the training samples for each of the task types in turn, system 300 begins to recover the training for each of the previously trained task types more quickly and gathers dormant knowledge. In some examples, because of the catastrophic forgetting that occurs when the training switches between the task types, system 300 generally only exhibits strong learning of the last trained task type. The sequential training strategy is described in more detail in Kirkpatrick, et al., “Overcoming Catastrophic Forgetting in Neural Networks,” Proceedings of the National Academy of Sciences, 2017, pp. 3521-3526, which is incorporated by reference in its entirety.

In some embodiments, attempts at addressing the limitations of the joint training and sequential training strategies have been proposed. In some examples, these include generation of computationally expensive Fisher information, use of task-specific modifications (e.g., packing and/or adaption strategies), which negatively impacts the goal of a unified system for all task types, and/or the like.

In some embodiments, system 300 may be trained according to a hybrid training strategy. In the hybrid training strategy, system 300 is initially trained using the sequential training strategy. This allows system 300 to gather the dormant knowledge of each of the task types. After a number of passes through the training samples for each of the task types, system 300 is then trained using the joint training strategy. Because of the dormant knowledge from the initial sequential training, the follow-on joint training is able to more effectively learn each of the task types even while performing multitasking, than joint training alone without the initial sequential training. By allowing system 300 to fully repress previously trained task types during the initial sequential training into dormant knowledge, the hybrid training strategy gives system 300 more time to focus on specializing for each of the task types. In some examples, the hybrid training strategy decouples the goal of learning each task type form learning how to do all task types together. Thus, when the training switches to the joint training strategy, system 300 is well prepared to learn each of the task types well.

In some embodiments, system 300 is trained according to a synthesize training strategy, which is a variation of the hybrid training strategy. In the synthesize training strategy, system 300 is initially trained using the sequential training strategy, but at fixed intervals and for a fixed number of iterations during the sequential training, the training switches to a joint training strategy across each of the task types that have been previously trained before returning to the sequential training strategy. By temporarily switching to the joint training strategy for the previously learned task types, system 300 is more often reminded of old task types and is also forced to synthesize old knowledge with new knowledge.

FIG. 7 is a simplified diagram of a method 700 of multitask learning according to some embodiments. One or more of the processes 710-780 of method 700 may be implemented, at least in part, in the form of executable code stored on non-transitory, tangible, machine-readable media that when run by one or more processors may cause the one or more processors to perform one or more of the processes 710-780. In some embodiments, method 700 may be used as a hybrid training strategy for training system 300, however, method 700 may also be used to train other multitasking systems other than system 300. In some embodiments, the task types trained by method 700 may include any of various natural language processing tasks, such as language translation, classification (e.g., sentiment analysis), question answering, and/or the like.

At a process 710, a training sample is selected according to a first training strategy. In some embodiments, the first training strategy is a sequential training strategy where training samples are selected from training samples for a first task type until each of the training samples for the first task type are selected before selecting training samples from a second task type different from the first task type until each of the training samples for the second task type are selected. Training samples are then selected from additional task types, if any, in turn with switching to the next task type occurring after each of the training samples for each of the task types are selected. In some examples, the selected training sample includes a natural language context, a natural language question, and a ground truth natural language answer corresponding to the context and the question.

At a process 720, the selected training sample is presented to a system. In some examples, the system is system 300. When the training sample is applied to the system it is fed forward through the various layers of the system according to the currently trained parameters (e.g., weights and biases) and an answer is generated. In some examples, the answer is a natural language phrase.

At a process 730, the system is adjusted based on error. The answer generated by the system during process 720 is compared to the ground truth answer for the selected training sample and the error for the selected training sample is determined. The error may then be fed back to system 300 using back propagation to update the various parameters (e.g., weights and biases) of the layers. In some examples, the back propagation may be performed using the stochastic gradient descent (SGD) training algorithm the adaptive moment estimation (ADAM) training algorithm, and/or the like. In some examples, the gradients used for the back propagation may be clipped to 1.0. In some examples, the learning decay rate may be the same rate used by Vaswani, et al., “Attention is All You Need,” arXiv preprint arXiv: 1706.03762, submitted Jun. 12, 2017.

At a process 740, it is determined whether to switch from the first training strategy to a second training strategy. In some examples, the decision to switch to the second training strategy occurs after each of the training samples for each of the task types has been selected a predetermined number of times. In some examples, the predetermined number of times may be five, although any other number such as three, four, and/or six or more may also be used. In some examples, one or more other factors may be used to make the determination about when to switch to the second training strategy. In some examples, the one or other factors may include monitoring changes in performance metrics for each of the task types with each pass through the training samples and making the switch when an improvement in each of the performance metrics after each pass improves by less than a threshold amount. When it is determined not to switch to the second training strategy, method 700 returns to process 710 where training samples continue to be selected according to the first training strategy. When it is determined to switch to the second learning training strategy, selection of the training samples occurs using the second training strategy beginning with a process 750.

At the process 750, a training sample is selected according to a second training strategy. In some examples, the second training strategy is a joint training strategy where training samples are selected equally from training samples for each of the task types.

At a process 760, the selected training sample is presented to the system using substantially the same process as process 720.

At a process 770, the system is adjusted based on error using substantially the same process as process 730.

At a process 780, it is determined whether the training is complete. In some examples, the training is complete after the training samples for each of the task types has been presented to the system a predetermined number of times. In some examples, the predetermined number of times may be eight, although any other number such as two to seven and/or nine or more may also be used. In some examples, one or more other factors may be used to make the determination about when training is complete. In some examples, the one or other factors may include monitoring changes in performance metrics for each of the task types with each pass through the training samples and noting that training is complete when an improvement in each of the performance metrics after each pass improves by less than a threshold amount. When it is determined that training is not complete, method 700 returns to process 740 where training samples continue to be selected according to the second training strategy. When it is determined that training is complete, method 700 ends and the trained system may now be used for any of the tasks for which it is trained.

After training is complete, the trained system may be used for any of the task types using a process substantially similar to process 720 and/or 760 where a context c and a question q may be presented to the system and fed forward through the various layers of the system according to the parameters (e.g., weights and biases) trained according to method 700. The generated answer then corresponds to the response to the presented context c and question q.

As discussed above and further emphasized here, FIG. 7 is merely an example which should not unduly limit the scope of the claims. One of ordinary skill in the art would recognize many variations, alternatives, and modifications. In some embodiments, method 700 is adapted to use the synthesize training strategy. In the synthesize training strategy, the first training strategy is a variation of the sequential training strategy and the second training strategy may be the joint training strategy. The variation of the sequential training strategy includes generally selecting the training sample according to the sequential training strategy except during intervals when the training sample is selected according to the joint training strategy. In some examples, the location and placement of the joint training strategy intervals may be based on a number of training iterations (e.g., a number of training samples presented to the system) for each task type. As a non-limiting example, selection of the training samples may include selecting 10,000 training samples for a first task type, selecting 1000 training samples jointly from each of the task types, selecting another 10,000 training samples for the first task type, selecting 1000 training samples joints from each of the task types, and then repeating until each of the training samples of the first task type are presented and then selecting 10,000 training samples for a second task type, etc. In some examples, the number of training samples before alternating between sequential and joint types of selection may be based on a percentage of a number of training samples for each task type (e.g., after anywhere from 10% to 25% of the number of training samples for the respective task type).

FIG. 8 is a simplified diagram of training performance according to some embodiments. More specifically, FIG. 8 shows the results of training system 300 according to four task types: English to German (EN-DE) language translation, English to French (EN-FR) language translation, question answering, and sentiment classification.

Training samples for the English to German and English to French translation task types are based on the International Workshop on Spoken Language Translation English to German (IWSLT EN->DE) and English to French (IWSLT EN->FR) training sets, which contain approximately 210,000 sentence pairs transcribed from TED talks. The performance metric used for the two language translation task types is the BLEU score.

Training samples for the question answering task type are based on the Stanford Question Answering Dataset (SQuAD), which includes 10,570 training samples based on questions related to paragraph samples from Wikipedia articles. The performance metric used for the question answering task type is the F1 score.

Training samples for the sentiment classification task type are based on the Stanford Sentiment Treebank (SST) where neutral examples are removed. The SST includes approximately 56,400 training samples based on movie reviews and their sentiment. The performance metric used for the sentiment classification task type is percentage of exact match.

FIG. 8 further shows the learning results for each task type according to the previously described performance metrics. Three results for each task type are shown. The single column indicates the respective performance metric when system 300 is trained using only training samples for the indicated task type. The joint column indicates the same performance metric when system 300 is trained using the joint training strategy. The hybrid column indicates the same performance metric when system 300 is trained using the hybrid training strategy of method 700. As expected, the single task type training results have the highest performance metrics as each version of system 300 was allowed to specialize in the single task. The joint column shows that use of the joint training strategy results in significantly poorer results, and the hybrid column shows the improvement of using the hybrid training strategy of method 700 over the joint training strategy. Further, with the exception of the sentiment classification task type, the hybrid training strategy of method 700 resulted in significantly superior performance results over the joint training strategy.

FIGS. 9A-9C are simplified diagrams of training performance according to some embodiments. FIG. 9A tracks the respective performance metrics over training iterations for each of the task types when system 300 is trained separately for each of the task types. (E.g., compare to the single column of FIG. 8.) Thus, FIG. 9A shows the results for four separately trained versions of system 300. FIG. 9B tracks the respective performance metrics when system 300 is trained according to the joint training strategy. As the performance metrics of FIG. 9B indicate, other than the SST classification task type, the version of system 300 trained using the joint training strategy did not learn any of the task types particularly well. FIG. 9C tracks the respective performance metrics when system 300 is trained according to the hybrid training strategy of method 700. The effects of catastrophic forgetting as the training samples switch from one task type to another during the initial sequential training are clearly apparent in FIG. 9C. After training samples from each of the task types have been presented five times using the sequential training strategy and the training strategy switches to the joint training strategy (at approximately iteration 250,000) the performance metrics rapidly improve to values that are better than the performance metrics of the joint training strategy only approach of FIG. 9B and more closely reach the performance metrics of the separately trained versions of system 300 in FIG. 9A.

FIGS. 10A and 10B are simplified diagrams of training performance based on training order according to some embodiments. FIGS. 10A and 10B demonstrate the impact of changing the order in which training for the various task types are presented to system 300 during the initial sequential training of the hybrid training strategy. As shown in FIG. 10A, when system 300 is first trained with training samples from the English to German (IWSLT EN->DE) language translation task type before being trained with training samples from the sentiment classification (SST) task type, system 300 is able to quickly recover its English to German translation knowledge when the training samples are again drawn from the English to German language translation task type. In contrast, FIG. 10B shows that when system 300 is first trained against the sentiment classification task type before being trained against the English to German language translation task type, system 300 is not able to learn the English to German language translation task type very well. It is speculated that this is due to the initial training against the English to German language translation task type leading to better initial encoding knowledge due to the greater complexity and richness of the training samples.

Some examples of computing devices, such as computing device 100 may include non-transitory, tangible, machine readable media that include executable code that when run by one or more processors (e.g., processor 210) may cause the one or more processors to perform the processes of method 700. Some common forms of machine readable media that may include the processes of method 700 are, for example, floppy disk, flexible disk, hard disk, magnetic tape, any other magnetic medium, CD-ROM, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, RAM, PROM, EPROM, FLASH-EPROM, any other memory chip or cartridge, and/or any other medium from which a processor or computer is adapted to read.

This description and the accompanying drawings that illustrate inventive aspects, embodiments, implementations, or applications should not be taken as limiting. Various mechanical, compositional, structural, electrical, and operational changes may be made without departing from the spirit and scope of this description and the claims. In some instances, well-known circuits, structures, or techniques have not been shown or described in detail in order not to obscure the embodiments of this disclosure Like numbers in two or more figures represent the same or similar elements.

In this description, specific details are set forth describing some embodiments consistent with the present disclosure. Numerous specific details are set forth in order to provide a thorough understanding of the embodiments. It will be apparent, however, to one skilled in the art that some embodiments may be practiced without some or all of these specific details. The specific embodiments disclosed herein are meant to be illustrative but not limiting. One skilled in the art may realize other elements that, although not specifically described here, are within the scope and the spirit of this disclosure. In addition, to avoid unnecessary repetition, one or more features shown and described in association with one embodiment may be incorporated into other embodiments unless specifically described otherwise or if the one or more features would make an embodiment non-functional.

Although illustrative embodiments have been shown and described, a wide range of modification, change and substitution is contemplated in the foregoing disclosure and in some instances, some features of the embodiments may be employed without a corresponding use of other features. One of ordinary skill in the art would recognize many variations, alternatives, and modifications. Thus, the scope of the invention should be limited only by the following claims, and it is appropriate that the claims be construed broadly and in a manner consistent with the scope of the embodiments disclosed herein. 

What is claimed is: 1-20. (canceled)
 21. A system for natural language processing, the system comprising: one or more processors; and a memory storing computer-executable instructions, which when executed by the one or more processors, cause the system to perform operations comprising: receiving, at an input layer, a natural language input of a question; performing a first encoding of a context-based word and a question-based word from the question into a context-based representation and a question-based representation; performing, using a bi-directional long-term short-term memory (biLSTM), a a second encoding of the context-based representation and the question-based representation; generating, using a long-term short-term memory (LSTM), a context-adjusted hidden state based at least in part from the context-based representation and the question-based representation; generating, by an attention network, a set of attention weights based on a first output of the biLSTM and a second output of the LSTM; generating, by a vocabulary layer, a first distribution over a plurality of words in a vocabulary based on the set of attention weights; generating, by a context layer, a second distribution over the context-based words based on the set of attention weights; and selecting a set of words for an answer to the question based on the first distribution and the second distribution.
 22. The system of claim 21, wherein the operations further comprise: generating, using a switch, the set of attention weights between the first distribution over the plurality of words from the vocabulary and the second distribution over the context-based words.
 23. The system of claim 21, wherein the operations further comprise: generating, using a switch, a composite distribution based on the set of attention weights; and selecting, using the switch, a word for inclusion in the answer using the composite distribution.
 24. The system of claim 21, wherein the input layer comprises one or more of a linear layer, a second biLSTM, a coattention layer, and a third biLSTM.
 25. The system of claim 21, wherein the operations further comprise: generating, via a coattention layer, an affinity matrix between the context-based representation and the question-based representation; generating second attention weights based on the affinity matrix; and generating weighted sums of the context-based representation and the question-based representation using the second attention weights.
 26. The system of claim 21, wherein the vocabulary layer comprises: a tanh layer for generating a hidden state based on the set of attention weights, the second encoding, and the context-adjusted hidden state; and a softmax layer for generating the first distribution over a plurality of words in a vocabulary.
 27. The system of claim 26, wherein the decoder, the LSTM, the attention network, the vocabulary layer, the context layer, and a switch iteratively select each word for the answer.
 28. The system of claim 26, wherein the transformer comprises a plurality of transformer layers, each of the plurality of transformer layers comprising an encoder portion having a first multi-head self-attention network and a decoder portion having a second multi-head self-attention network and a third multi-head attention network.
 29. The system of claim 21, wherein the system is trained using a hybrid training strategy where the system is first trained against a plurality of task types using a sequential training strategy and is then trained against the plurality of task types using a joint training strategy.
 30. The system of claim 29, wherein each of the plurality of task types is a language translation task type, a classification task type, or a question answering task type.
 31. A method for natural language processing, the method comprising: receiving, at an input layer, a natural language input of a question; performing a first encoding of a context-based word and a question-based word from the question into a context-based representation and a question-based representation; performing, using a bi-directional long-term short-term memory (biLSTM), a a second encoding of the context-based representation and the question-based representation; generating, using a long-term short-term memory (LSTM), a context-adjusted hidden state based at least in part from the context-based representation and the question-based representation; generating, by an attention network, a set of attention weights based on a first output of the biLSTM and a second output of the LSTM; generating, by a vocabulary layer, a first distribution over a plurality of words in a vocabulary based on the set of attention weights; generating, by a context layer, a second distribution over the context-based words based on the set of attention weights; and selecting a set of words for an answer to the question based on the first distribution and the second distribution.
 32. The method of claim 31, further comprising: generating, using a switch, the set of attention weights between the first distribution over the plurality of words from the vocabulary and the second distribution over the context-based words.
 33. The method of claim 31, further comprising: generating, using a switch, a composite distribution based on the set of attention weights; and selecting, using the switch, a word for inclusion in the answer using the composite distribution.
 34. The method of claim 31, further comprising: generating, via a coattention layer, an affinity matrix between the context-based representation and the question-based representation; generating second attention weights based on the affinity matrix; and generating weighted sums of the context-based representation and the question-based representation using the second attention weights.
 35. The method of claim 31, wherein the vocabulary layer comprises: a tanh layer for generating a hidden state based on the set of attention weights, the second encoding, and the context-adjusted hidden state; and a softmax layer for generating the first distribution over a plurality of words in a vocabulary.
 36. The method of claim 31, further comprising: encoding and decoding, using a self-attention-based transformer, an output of the input layer.
 37. The method of claim 36, wherein the transformer comprises a plurality of transformer layers, each of the plurality of transformer layers comprising an encoder portion having a first multi-head self-attention network and a decoder portion having a second multi-head self-attention network and a third multi-head attention network.
 38. A non-transitory processor-readable medium storing processor-executable instructions for natural language processing, the instructions being executable by a processor to perform operations comprising: receiving, at an input layer, a natural language input of a question; performing a first encoding of a context-based word and a question-based word from the question into a context-based representation and a question-based representation; performing, using a bi-directional long-term short-term memory (biLSTM), a a second encoding of the context-based representation and the question-based representation; generating, using a long-term short-term memory (LSTM), a context-adjusted hidden state based at least in part from the context-based representation and the question-based representation; generating, by an attention network, a set of attention weights based on a first output of the biLSTM and a second output of the LSTM; generating, by a vocabulary layer, a first distribution over a plurality of words in a vocabulary based on the set of attention weights; generating, by a context layer, a second distribution over the context-based words based on the set of attention weights; and selecting a set of words for an answer to the question based on the first distribution and the second distribution.
 39. The medium of claim 38, wherein the operations further comprise: generating, using a switch, a composite distribution based on the set of attention weights; and selecting, using the switch, a word for inclusion in the answer using the composite distribution.
 40. The medium of claim 38, wherein the operations further comprise: generating, via a coattention layer, an affinity matrix between the context-based representation and the question-based representation; generating second attention weights based on the affinity matrix; and generating weighted sums of the context-based representation and the question-based representation using the second attention weights. 